package com.ankifyh.BujoTemplateGenerator;

import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.provider.Settings;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import io.noties.markwon.Markwon;


public class MainActivity extends Activity {

    private static final String TAG = "MainActivity";
    // 引用Constants类中的LOGSEQ_TEMPLATE_FILE_PATH常量
    private static final String LOGSEQ_TEMPLATE_FILE_PATH = Constants.LOGSEQ_TEMPLATE_FILE_PATH;
    private EditText inputText;
    private EditText templateEditor;
    private TextView textViewMarkdown;
    private Handler handler = new Handler();
    private Runnable saveTask;
    private static final int DELAY_MILLIS = 100; // 延迟时间，单位毫秒


    /**
     * 创建或写入日志序列化模板文件。
     * 该方法首先检查指定路径下的日志序列化模板文件是否存在，如果不存在，则创建新文件并写入模板内容。
     *
     * @param context 上下文对象，用于访问应用的环境信息。
     */
    private void createOrWriteLogSeqTemplate(Context context) {
        // 获取外部存储路径
        String externalStoragePath = Environment.getExternalStorageDirectory().getPath();

        // 创建File对象，指定模板文件路径
        File logSeqTemplateFile = new File(LOGSEQ_TEMPLATE_FILE_PATH);

        // 检查文件是否存在，若不存在则进行创建和写入操作
        if (!logSeqTemplateFile.exists()) {
            try {
                // 创建新文件
                logSeqTemplateFile.createNewFile();
                // 写入模板内容
                writeLogSeqTemplate(logSeqTemplateFile);
                // 记录成功创建日志
                Log.d(TAG, "LogSeq template file created: " + LOGSEQ_TEMPLATE_FILE_PATH);
            } catch (IOException e) {
                // 记录创建或写入失败的日志
                Log.e(TAG, "Failed to create or write LogSeq template file", e);
            }
        } else {
            // 记录文件已存在的日志
            Log.d(TAG, "LogSeq template file already exists: " + LOGSEQ_TEMPLATE_FILE_PATH);
        }
    }

    /**
     * 该方法主要用于生成并写入一个LogSeq模板文件
     *
     * @param file 指定的文件对象，该文件代表LogSeq模板文件。
     * @throws IOException 如果文件写入过程中发生错误，或者无法创建文件。
     */
    private void writeLogSeqTemplate(File file) throws IOException {
        // 定义模板内容，其中包括时间标签、当前状态和下一步行动等信息
        String content = "`{{{HH:mm:ss EEEE dd-MMMM-yyyy}}}[[[US]]]标签\u200B🏷` #  \n`💭just now`  \n`🤔next step`  \n`💬now`";

        // 创建FileWriter对象，并使用try-with-resources确保资源被正确关闭，然后写入模板内容
        try (FileWriter writer = new FileWriter(file)) {
            writer.write(content);
        } catch (IOException e) {
            // 如果写入过程中发生IOException，则重新抛出包含详细错误信息的IOException
            throw new IOException("Failed to write content to LogSeq template file", e);
        }
    }

    //将模板文件中的模板展示到textViewMarkdown和templateEditor中
    private void loadFileContent(String filePath) {
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            StringBuilder contentBuilder = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                contentBuilder.append(line).append("\n");
            }
            String fileContent = contentBuilder.toString();

            // 使用Markwon解析Markdown
            Markwon markwon = Markwon.builder(this)
                    .build();
            markwon.setMarkdown(textViewMarkdown, fileContent);
            templateEditor.setText(fileContent);
        } catch (IOException e) {
            Log.e(TAG, "Failed to read content from file", e);
        }

    }

    private void setupTemplateEditorListener() {
        templateEditor.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {

                handler.removeCallbacks(saveTask);
            }

            @Override
            public void afterTextChanged(Editable s) {
                saveTask = () -> {
                    //updateMarkdownDisplay(String.valueOf(s));
                    String template = templateEditor.getText().toString().trim();
                    if (!template.isEmpty()) {
                        try {
                            File outputFile = new File(LOGSEQ_TEMPLATE_FILE_PATH);
                            FileWriter writer = new FileWriter(outputFile);
                            writer.write(template);
                            writer.close();
                            // 更新Markwon的渲染
                            updateMarkdownDisplay(template);
                            //Toast.makeText(MainActivity.this, "模板已保存", Toast.LENGTH_SHORT).show();
                        } catch (IOException e) {
                            Log.e(TAG, "保存模板到文件时出错", e);
                            Toast.makeText(MainActivity.this, "保存模板时出错", Toast.LENGTH_SHORT).show();
                        }
                    } else {
                        Toast.makeText(MainActivity.this, "请输入模板内容", Toast.LENGTH_SHORT).show();
                    }
                };
                handler.postDelayed(saveTask, DELAY_MILLIS);
            }
        });
    }

    private void updateMarkdownDisplay(String template) {
        Markwon markwon = Markwon.builder(this)
                .build();
        markwon.setMarkdown(textViewMarkdown, template);
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 检查并请求写入外部存储权限
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            if (!Environment.isExternalStorageManager()) {
                // 引导用户到设置页面开启权限
                Intent manageAllFilesIntent = new Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION);
                manageAllFilesIntent.setData(Uri.parse("package:" + getPackageName()));
                startActivityForResult(manageAllFilesIntent, Constants.MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE);
                return;
            }
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions(this,
                        new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                        Constants.MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE);
                return;
            }
        }
        //首次启动应用检查模板文件是否存在，然后创建或写入模板文件
        createOrWriteLogSeqTemplate(this);

        //初始化所有控件
        inputText = findViewById(R.id.input_text);
        textViewMarkdown = findViewById(R.id.textViewMarkdown);
        templateEditor = findViewById(R.id.temp_edit);
        Button testButton = findViewById(R.id.test_button);

        //测试生成含当前时间的模板
        testButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String link = inputText.getText().toString().trim();
                if (!link.isEmpty()) {
                    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(link));
                    startActivity(intent);
                } else {
                    Toast.makeText(MainActivity.this, "请输入专属链接后再试", Toast.LENGTH_SHORT).show();
                }
            }

        });

        //将模板文件中存储的模板文件写入展示框和编辑框
        loadFileContent(LOGSEQ_TEMPLATE_FILE_PATH);

        setupTemplateEditorListener();


    }
    // 权限请求回调
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == Constants.MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE) {
            if (resultCode == Activity.RESULT_OK) {
                // 用户已授权，继续处理文件操作
                //首次启动应用检查模板文件是否存在，然后创建或写入模板文件
                createOrWriteLogSeqTemplate(this);
            } else {
                // 用户未授权，可能需要提示用户并处理这种情况
                String message = "拒绝了外部存储读取权限。";
                Toast.makeText(this, message, Toast.LENGTH_SHORT).show(); // 显示Toast消息
            }
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == Constants.MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // 用户同意了权限请求，可以在这里继续创建文件
                //首次启动应用检查模板文件是否存在，然后创建或写入模板文件
                createOrWriteLogSeqTemplate(this);
            } else {
                // 用户拒绝了权限请求，可能需要提示用户并处理这种情况
                String message = "拒绝了外部存储写入权限。";
                Toast.makeText(this, message, Toast.LENGTH_SHORT).show(); // 显示Toast消息
            }
        }
    }

}